#include "threadPool.h"
#include <iostream>
#include <chrono>
#include <random>
#include <atomic>

// 全局计数器，用于测试线程安全
std::atomic<int> counter(0);

// 测试函数1：简单的计算任务
void simpleTask(int taskId)
{
    std::cout << "任务ID： " << taskId << " 在哪一个线程： "
              << std::this_thread::get_id() << std::endl;

    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    std::cout << "任务ID： " << taskId << " 完成!" << std::endl;
}

// 测试函数2：计数器递增任务
void counterTask()
{
    for (int i = 0; i < 1000; ++i)
    {
        counter++;
    }
    std::cout << "计数器任务在哪一个线程： "
              << std::this_thread::get_id() << std::endl;
}

// 测试函数3：CPU密集型任务
void cpuIntensiveTask(int n)
{
    long long sum = 0;
    for (int i = 0; i < n; ++i)
    {
        sum += i * i;
    }
    std::cout << "CPU intensive task completed, sum = " << sum
              << " on thread " << std::this_thread::get_id() << std::endl;
}

// 测试函数4：随机延迟任务
void randomDelayTask(int taskId)
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(50, 200);

    int delay = dis(gen);
    std::this_thread::sleep_for(std::chrono::milliseconds(delay));

    std::cout << "Random delay task " << taskId
              << " (delay: " << delay << "ms) completed!" << std::endl;
}

// 测试1：基本功能测试
void test1_basicFunctionality()
{
    std::cout << "\n--- 测试1：基本功能测试 ---" << std::endl;
    ThreadPool pool(4); // 创建4个工作线程的线程池

    // 提交5个简单任务
    for (int i = 1; i <= 100; ++i)
    {
        pool.enQueueTask([i]()
                         { simpleTask(i); });
    }

    // 等待一段时间让任务完成
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
}

// 测试2：线程安全测试
void test2_threadSafety()
{
    std::cout << "\n--- 测试2：线程安全测试 ---" << std::endl;
    counter = 0; // 重置计数器

    ThreadPool pool(8); // 创建8个工作线程

    // 提交10个计数器任务，每个任务递增1000次
    for (int i = 0; i < 10; ++i)
    {
        pool.enQueueTask(counterTask);
    }

    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::milliseconds(200));

    std::cout << "最终计数器值: " << counter << " (期望值: 10000)" << std::endl;
}

// 测试3：CPU密集型任务测试
void test3_cpuIntensiveTasks()
{
    std::cout << "\n--- 测试3：CPU密集型任务测试 ---" << std::endl;
    ThreadPool pool(std::thread::hardware_concurrency()); // 使用CPU核心数
    std::cout << "使用 " << std::thread::hardware_concurrency() << " 个线程" << std::endl;

    auto start = std::chrono::high_resolution_clock::now();

    // 提交4个CPU密集型任务
    for (int i = 0; i < 4; ++i)
    {
        pool.enQueueTask([i]()
                         { cpuIntensiveTask(1000000); });
    }

    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "CPU密集型任务总耗时: " << duration.count() << "ms" << std::endl;
}

// 测试4：大量任务测试
void test4_massiveTasks()
{
    std::cout << "\n--- 测试4：大量任务测试 ---" << std::endl;
    ThreadPool pool(6); // 6个工作线程

    auto start = std::chrono::high_resolution_clock::now();

    // 提交20个随机延迟任务
    for (int i = 1; i <= 20; ++i)
    {
        pool.enQueueTask([i]()
                         { randomDelayTask(i); });
    }

    // 等待所有任务完成
    std::this_thread::sleep_for(std::chrono::milliseconds(2000));

    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "20个任务总耗时: " << duration.count() << "ms" << std::endl;
}

// 测试5：混合任务测试
void test5_mixedTasks()
{
    std::cout << "\n--- 测试5：混合任务测试 ---" << std::endl;
    ThreadPool pool(4);

    // 混合提交不同类型的任务
    pool.enQueueTask([]()
                     { simpleTask(101); });
    pool.enQueueTask(counterTask);
    pool.enQueueTask([]()
                     { cpuIntensiveTask(500000); });
    pool.enQueueTask([]()
                     { randomDelayTask(102); });
    pool.enQueueTask([]()
                     { std::cout << "Lambda task executed on thread "
                                 << std::this_thread::get_id() << std::endl; });

    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}

int main()
{
    std::cout << "=== 线程池测试开始 ===" << std::endl;
    std::cout << "主线程 ID: " << std::this_thread::get_id() << std::endl;

    // 执行所有测试
    // test1_basicFunctionality();
    test2_threadSafety();
    // test3_cpuIntensiveTasks();
    // test4_massiveTasks();
    // test5_mixedTasks();
    // test5_mixedTasks();
    // std

    std::cout << "\n=== 线程池测试完成 ===" << std::endl;
    return 0;
}